/*
 *
 *    Copyright (c) 2021 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP

// Prevent multiple inclusion
#pragma once

#include <app/common/gen/af-structs.h>
#include <app/util/af-types.h>
#include <app/util/basic-types.h>

#include <app/Command.h>
#include <lib/support/Span.h>

/** @brief Cluster Init
 *
 * This function is called when a specific cluster is initialized. It gives the
 * application an opportunity to take care of cluster initialization procedures.
 * It is called exactly once for each endpoint where cluster is present.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 */
void emberAfClusterInitCallback(chip::EndpointId endpoint, chip::ClusterId clusterId);

// Cluster Init Functions

/** @brief Account Login Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfAccountLoginClusterInitCallback(chip::EndpointId endpoint);

/** @brief Application Basic Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfApplicationBasicClusterInitCallback(chip::EndpointId endpoint);

/** @brief Application Launcher Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfApplicationLauncherClusterInitCallback(chip::EndpointId endpoint);

/** @brief Audio Output Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfAudioOutputClusterInitCallback(chip::EndpointId endpoint);

/** @brief Barrier Control Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBarrierControlClusterInitCallback(chip::EndpointId endpoint);

/** @brief Basic Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBasicClusterInitCallback(chip::EndpointId endpoint);

/** @brief Binary Input (Basic) Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBinaryInputBasicClusterInitCallback(chip::EndpointId endpoint);

/** @brief Binding Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBindingClusterInitCallback(chip::EndpointId endpoint);

/** @brief Bridged Device Basic Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBridgedDeviceBasicClusterInitCallback(chip::EndpointId endpoint);

/** @brief Color Control Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfColorControlClusterInitCallback(chip::EndpointId endpoint);

/** @brief Content Launcher Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfContentLauncherClusterInitCallback(chip::EndpointId endpoint);

/** @brief Descriptor Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDescriptorClusterInitCallback(chip::EndpointId endpoint);

/** @brief Diagnostic Logs Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDiagnosticLogsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Door Lock Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDoorLockClusterInitCallback(chip::EndpointId endpoint);

/** @brief Ethernet Network Diagnostics Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfEthernetNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Fixed Label Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfFixedLabelClusterInitCallback(chip::EndpointId endpoint);

/** @brief Flow Measurement Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfFlowMeasurementClusterInitCallback(chip::EndpointId endpoint);

/** @brief General Commissioning Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGeneralCommissioningClusterInitCallback(chip::EndpointId endpoint);

/** @brief General Diagnostics Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGeneralDiagnosticsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Group Key Management Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGroupKeyManagementClusterInitCallback(chip::EndpointId endpoint);

/** @brief Groups Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGroupsClusterInitCallback(chip::EndpointId endpoint);

/** @brief IAS Zone Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfIasZoneClusterInitCallback(chip::EndpointId endpoint);

/** @brief Identify Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfIdentifyClusterInitCallback(chip::EndpointId endpoint);

/** @brief Keypad Input Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfKeypadInputClusterInitCallback(chip::EndpointId endpoint);

/** @brief Level Control Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfLevelControlClusterInitCallback(chip::EndpointId endpoint);

/** @brief Low Power Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfLowPowerClusterInitCallback(chip::EndpointId endpoint);

/** @brief Media Input Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfMediaInputClusterInitCallback(chip::EndpointId endpoint);

/** @brief Media Playback Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfMediaPlaybackClusterInitCallback(chip::EndpointId endpoint);

/** @brief Network Commissioning Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfNetworkCommissioningClusterInitCallback(chip::EndpointId endpoint);

/** @brief OTA Software Update Provider Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOtaSoftwareUpdateProviderClusterInitCallback(chip::EndpointId endpoint);

/** @brief Occupancy Sensing Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOccupancySensingClusterInitCallback(chip::EndpointId endpoint);

/** @brief On/off Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOnOffClusterInitCallback(chip::EndpointId endpoint);

/** @brief Operational Credentials Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOperationalCredentialsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Pressure Measurement Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfPressureMeasurementClusterInitCallback(chip::EndpointId endpoint);

/** @brief Pump Configuration and Control Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfPumpConfigurationAndControlClusterInitCallback(chip::EndpointId endpoint);

/** @brief Relative Humidity Measurement Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfRelativeHumidityMeasurementClusterInitCallback(chip::EndpointId endpoint);

/** @brief Scenes Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfScenesClusterInitCallback(chip::EndpointId endpoint);

/** @brief Software Diagnostics Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfSoftwareDiagnosticsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Switch Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfSwitchClusterInitCallback(chip::EndpointId endpoint);

/** @brief TV Channel Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTvChannelClusterInitCallback(chip::EndpointId endpoint);

/** @brief Target Navigator Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTargetNavigatorClusterInitCallback(chip::EndpointId endpoint);

/** @brief Temperature Measurement Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTemperatureMeasurementClusterInitCallback(chip::EndpointId endpoint);

/** @brief Test Cluster Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTestClusterClusterInitCallback(chip::EndpointId endpoint);

/** @brief Thermostat Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfThermostatClusterInitCallback(chip::EndpointId endpoint);

/** @brief Thread Network Diagnostics Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfThreadNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Wake on LAN Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWakeOnLanClusterInitCallback(chip::EndpointId endpoint);

/** @brief WiFi Network Diagnostics Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWiFiNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);

/** @brief Window Covering Cluster Init
 *
 * Cluster Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWindowCoveringClusterInitCallback(chip::EndpointId endpoint);

// Cluster Server/Client Init Functions

//
// Account Login Cluster server
//

/** @brief Account Login Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfAccountLoginClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Account Login Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfAccountLoginClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Account Login Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfAccountLoginClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  uint16_t manufacturerCode);

/** @brief Account Login Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfAccountLoginClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                         uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Account Login Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfAccountLoginClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                          EmberAfAttributeType attributeType, uint16_t size,
                                                                          uint8_t * value);

/** @brief Account Login Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfAccountLoginClusterServerTickCallback(chip::EndpointId endpoint);

//
// Application Basic Cluster server
//

/** @brief Application Basic Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfApplicationBasicClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Application Basic Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfApplicationBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Application Basic Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfApplicationBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                      chip::AttributeId attributeId,
                                                                                      uint16_t manufacturerCode);

/** @brief Application Basic Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfApplicationBasicClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                             EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                             EmberStatus status);

/** @brief Application Basic Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfApplicationBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              EmberAfAttributeType attributeType, uint16_t size,
                                                                              uint8_t * value);

/** @brief Application Basic Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfApplicationBasicClusterServerTickCallback(chip::EndpointId endpoint);

//
// Application Launcher Cluster server
//

/** @brief Application Launcher Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfApplicationLauncherClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Application Launcher Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfApplicationLauncherClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Application Launcher Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfApplicationLauncherClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                         chip::AttributeId attributeId,
                                                                                         uint16_t manufacturerCode);

/** @brief Application Launcher Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfApplicationLauncherClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                EmberStatus status);

/** @brief Application Launcher Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfApplicationLauncherClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 EmberAfAttributeType attributeType, uint16_t size,
                                                                                 uint8_t * value);

/** @brief Application Launcher Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfApplicationLauncherClusterServerTickCallback(chip::EndpointId endpoint);

//
// Audio Output Cluster server
//

/** @brief Audio Output Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfAudioOutputClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Audio Output Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfAudioOutputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Audio Output Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfAudioOutputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 uint16_t manufacturerCode);

/** @brief Audio Output Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfAudioOutputClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                        uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Audio Output Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfAudioOutputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                         EmberAfAttributeType attributeType, uint16_t size,
                                                                         uint8_t * value);

/** @brief Audio Output Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfAudioOutputClusterServerTickCallback(chip::EndpointId endpoint);

//
// Barrier Control Cluster server
//

/** @brief Barrier Control Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBarrierControlClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Barrier Control Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfBarrierControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Barrier Control Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfBarrierControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);

/** @brief Barrier Control Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfBarrierControlClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);

/** @brief Barrier Control Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfBarrierControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);

/** @brief Barrier Control Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfBarrierControlClusterServerTickCallback(chip::EndpointId endpoint);

//
// Basic Cluster server
//

/** @brief Basic Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBasicClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Basic Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Basic Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                           uint16_t manufacturerCode);

/** @brief Basic Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfBasicClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                  uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Basic Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                   EmberAfAttributeType attributeType, uint16_t size,
                                                                   uint8_t * value);

/** @brief Basic Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfBasicClusterServerTickCallback(chip::EndpointId endpoint);

//
// Binary Input (Basic) Cluster server
//

/** @brief Binary Input (Basic) Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBinaryInputBasicClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Binary Input (Basic) Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfBinaryInputBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Binary Input (Basic) Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfBinaryInputBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                      chip::AttributeId attributeId,
                                                                                      uint16_t manufacturerCode);

/** @brief Binary Input (Basic) Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfBinaryInputBasicClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                             EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                             EmberStatus status);

/** @brief Binary Input (Basic) Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfBinaryInputBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              EmberAfAttributeType attributeType, uint16_t size,
                                                                              uint8_t * value);

/** @brief Binary Input (Basic) Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfBinaryInputBasicClusterServerTickCallback(chip::EndpointId endpoint);

//
// Binding Cluster server
//

/** @brief Binding Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBindingClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Binding Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfBindingClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Binding Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfBindingClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId,
                                                                             uint16_t manufacturerCode);

/** @brief Binding Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfBindingClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                    uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Binding Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfBindingClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                     EmberAfAttributeType attributeType, uint16_t size,
                                                                     uint8_t * value);

/** @brief Binding Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfBindingClusterServerTickCallback(chip::EndpointId endpoint);

//
// Bridged Device Basic Cluster server
//

/** @brief Bridged Device Basic Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfBridgedDeviceBasicClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Bridged Device Basic Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfBridgedDeviceBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Bridged Device Basic Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfBridgedDeviceBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        uint16_t manufacturerCode);

/** @brief Bridged Device Basic Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfBridgedDeviceBasicClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                               EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                               EmberStatus status);

/** @brief Bridged Device Basic Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfBridgedDeviceBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                EmberAfAttributeType attributeType, uint16_t size,
                                                                                uint8_t * value);

/** @brief Bridged Device Basic Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfBridgedDeviceBasicClusterServerTickCallback(chip::EndpointId endpoint);

//
// Color Control Cluster server
//

/** @brief Color Control Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfColorControlClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Color Control Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfColorControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Color Control Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  uint16_t manufacturerCode);

/** @brief Color Control Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfColorControlClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                         uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Color Control Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                          EmberAfAttributeType attributeType, uint16_t size,
                                                                          uint8_t * value);

/** @brief Color Control Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfColorControlClusterServerTickCallback(chip::EndpointId endpoint);

//
// Content Launcher Cluster server
//

/** @brief Content Launcher Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfContentLauncherClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Content Launcher Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfContentLauncherClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Content Launcher Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfContentLauncherClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                     chip::AttributeId attributeId,
                                                                                     uint16_t manufacturerCode);

/** @brief Content Launcher Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfContentLauncherClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                            EmberStatus status);

/** @brief Content Launcher Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfContentLauncherClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId,
                                                                             EmberAfAttributeType attributeType, uint16_t size,
                                                                             uint8_t * value);

/** @brief Content Launcher Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfContentLauncherClusterServerTickCallback(chip::EndpointId endpoint);

//
// Descriptor Cluster server
//

/** @brief Descriptor Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDescriptorClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Descriptor Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfDescriptorClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Descriptor Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfDescriptorClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                uint16_t manufacturerCode);

/** @brief Descriptor Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfDescriptorClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                       uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Descriptor Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfDescriptorClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                        EmberAfAttributeType attributeType, uint16_t size,
                                                                        uint8_t * value);

/** @brief Descriptor Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfDescriptorClusterServerTickCallback(chip::EndpointId endpoint);

//
// Diagnostic Logs Cluster server
//

/** @brief Diagnostic Logs Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDiagnosticLogsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Diagnostic Logs Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfDiagnosticLogsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Diagnostic Logs Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfDiagnosticLogsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);

/** @brief Diagnostic Logs Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfDiagnosticLogsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);

/** @brief Diagnostic Logs Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfDiagnosticLogsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);

/** @brief Diagnostic Logs Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfDiagnosticLogsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Door Lock Cluster server
//

/** @brief Door Lock Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfDoorLockClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Door Lock Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfDoorLockClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Door Lock Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfDoorLockClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              uint16_t manufacturerCode);

/** @brief Door Lock Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfDoorLockClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                     uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Door Lock Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfDoorLockClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                      EmberAfAttributeType attributeType, uint16_t size,
                                                                      uint8_t * value);

/** @brief Door Lock Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfDoorLockClusterServerTickCallback(chip::EndpointId endpoint);

//
// Ethernet Network Diagnostics Cluster server
//

/** @brief Ethernet Network Diagnostics Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfEthernetNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Ethernet Network Diagnostics Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfEthernetNetworkDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId);

/** @brief Ethernet Network Diagnostics Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfEthernetNetworkDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                                chip::AttributeId attributeId,
                                                                                                uint16_t manufacturerCode);

/** @brief Ethernet Network Diagnostics Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfEthernetNetworkDiagnosticsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                       EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                       EmberStatus status);

/** @brief Ethernet Network Diagnostics Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfEthernetNetworkDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        EmberAfAttributeType attributeType,
                                                                                        uint16_t size, uint8_t * value);

/** @brief Ethernet Network Diagnostics Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfEthernetNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Fixed Label Cluster server
//

/** @brief Fixed Label Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfFixedLabelClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Fixed Label Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfFixedLabelClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Fixed Label Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfFixedLabelClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                uint16_t manufacturerCode);

/** @brief Fixed Label Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfFixedLabelClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                       uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Fixed Label Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfFixedLabelClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                        EmberAfAttributeType attributeType, uint16_t size,
                                                                        uint8_t * value);

/** @brief Fixed Label Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfFixedLabelClusterServerTickCallback(chip::EndpointId endpoint);

//
// Flow Measurement Cluster server
//

/** @brief Flow Measurement Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfFlowMeasurementClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Flow Measurement Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfFlowMeasurementClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Flow Measurement Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfFlowMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                     chip::AttributeId attributeId,
                                                                                     uint16_t manufacturerCode);

/** @brief Flow Measurement Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfFlowMeasurementClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                            EmberStatus status);

/** @brief Flow Measurement Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfFlowMeasurementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId,
                                                                             EmberAfAttributeType attributeType, uint16_t size,
                                                                             uint8_t * value);

/** @brief Flow Measurement Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfFlowMeasurementClusterServerTickCallback(chip::EndpointId endpoint);

//
// General Commissioning Cluster server
//

/** @brief General Commissioning Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGeneralCommissioningClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief General Commissioning Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfGeneralCommissioningClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief General Commissioning Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfGeneralCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                          chip::AttributeId attributeId,
                                                                                          uint16_t manufacturerCode);

/** @brief General Commissioning Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfGeneralCommissioningClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                 EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                 EmberStatus status);

/** @brief General Commissioning Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfGeneralCommissioningClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  EmberAfAttributeType attributeType, uint16_t size,
                                                                                  uint8_t * value);

/** @brief General Commissioning Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfGeneralCommissioningClusterServerTickCallback(chip::EndpointId endpoint);

//
// General Diagnostics Cluster server
//

/** @brief General Diagnostics Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGeneralDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief General Diagnostics Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfGeneralDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief General Diagnostics Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfGeneralDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        uint16_t manufacturerCode);

/** @brief General Diagnostics Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfGeneralDiagnosticsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                               EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                               EmberStatus status);

/** @brief General Diagnostics Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfGeneralDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                EmberAfAttributeType attributeType, uint16_t size,
                                                                                uint8_t * value);

/** @brief General Diagnostics Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfGeneralDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Group Key Management Cluster server
//

/** @brief Group Key Management Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGroupKeyManagementClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Group Key Management Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfGroupKeyManagementClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Group Key Management Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfGroupKeyManagementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        uint16_t manufacturerCode);

/** @brief Group Key Management Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfGroupKeyManagementClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                               EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                               EmberStatus status);

/** @brief Group Key Management Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfGroupKeyManagementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                EmberAfAttributeType attributeType, uint16_t size,
                                                                                uint8_t * value);

/** @brief Group Key Management Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfGroupKeyManagementClusterServerTickCallback(chip::EndpointId endpoint);

//
// Groups Cluster server
//

/** @brief Groups Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfGroupsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Groups Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfGroupsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Groups Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfGroupsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            uint16_t manufacturerCode);

/** @brief Groups Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfGroupsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                   uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Groups Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfGroupsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                    EmberAfAttributeType attributeType, uint16_t size,
                                                                    uint8_t * value);

/** @brief Groups Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfGroupsClusterServerTickCallback(chip::EndpointId endpoint);

//
// IAS Zone Cluster server
//

/** @brief IAS Zone Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfIasZoneClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief IAS Zone Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfIasZoneClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief IAS Zone Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfIasZoneClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId,
                                                                             uint16_t manufacturerCode);

/** @brief IAS Zone Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfIasZoneClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                    uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief IAS Zone Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfIasZoneClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                     EmberAfAttributeType attributeType, uint16_t size,
                                                                     uint8_t * value);

/** @brief IAS Zone Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfIasZoneClusterServerTickCallback(chip::EndpointId endpoint);

//
// Identify Cluster server
//

/** @brief Identify Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfIdentifyClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Identify Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfIdentifyClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Identify Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfIdentifyClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              uint16_t manufacturerCode);

/** @brief Identify Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfIdentifyClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                     uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Identify Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfIdentifyClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                      EmberAfAttributeType attributeType, uint16_t size,
                                                                      uint8_t * value);

/** @brief Identify Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfIdentifyClusterServerTickCallback(chip::EndpointId endpoint);

//
// Keypad Input Cluster server
//

/** @brief Keypad Input Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfKeypadInputClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Keypad Input Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfKeypadInputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Keypad Input Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfKeypadInputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 uint16_t manufacturerCode);

/** @brief Keypad Input Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfKeypadInputClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                        uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Keypad Input Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfKeypadInputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                         EmberAfAttributeType attributeType, uint16_t size,
                                                                         uint8_t * value);

/** @brief Keypad Input Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfKeypadInputClusterServerTickCallback(chip::EndpointId endpoint);

//
// Level Control Cluster server
//

/** @brief Level Control Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfLevelControlClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Level Control Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfLevelControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Level Control Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  uint16_t manufacturerCode);

/** @brief Level Control Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfLevelControlClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                         uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Level Control Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                          EmberAfAttributeType attributeType, uint16_t size,
                                                                          uint8_t * value);

/** @brief Level Control Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfLevelControlClusterServerTickCallback(chip::EndpointId endpoint);

//
// Low Power Cluster server
//

/** @brief Low Power Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfLowPowerClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Low Power Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfLowPowerClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Low Power Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfLowPowerClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              uint16_t manufacturerCode);

/** @brief Low Power Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfLowPowerClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                     uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Low Power Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfLowPowerClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                      EmberAfAttributeType attributeType, uint16_t size,
                                                                      uint8_t * value);

/** @brief Low Power Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfLowPowerClusterServerTickCallback(chip::EndpointId endpoint);

//
// Media Input Cluster server
//

/** @brief Media Input Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfMediaInputClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Media Input Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfMediaInputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Media Input Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfMediaInputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                uint16_t manufacturerCode);

/** @brief Media Input Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfMediaInputClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                       uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Media Input Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfMediaInputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                        EmberAfAttributeType attributeType, uint16_t size,
                                                                        uint8_t * value);

/** @brief Media Input Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfMediaInputClusterServerTickCallback(chip::EndpointId endpoint);

//
// Media Playback Cluster server
//

/** @brief Media Playback Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfMediaPlaybackClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Media Playback Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfMediaPlaybackClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Media Playback Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfMediaPlaybackClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                   chip::AttributeId attributeId,
                                                                                   uint16_t manufacturerCode);

/** @brief Media Playback Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfMediaPlaybackClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                          EmberStatus status);

/** @brief Media Playback Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfMediaPlaybackClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                           EmberAfAttributeType attributeType, uint16_t size,
                                                                           uint8_t * value);

/** @brief Media Playback Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfMediaPlaybackClusterServerTickCallback(chip::EndpointId endpoint);

//
// Network Commissioning Cluster server
//

/** @brief Network Commissioning Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfNetworkCommissioningClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Network Commissioning Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfNetworkCommissioningClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Network Commissioning Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfNetworkCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                          chip::AttributeId attributeId,
                                                                                          uint16_t manufacturerCode);

/** @brief Network Commissioning Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfNetworkCommissioningClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                 EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                 EmberStatus status);

/** @brief Network Commissioning Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfNetworkCommissioningClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  EmberAfAttributeType attributeType, uint16_t size,
                                                                                  uint8_t * value);

/** @brief Network Commissioning Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfNetworkCommissioningClusterServerTickCallback(chip::EndpointId endpoint);

//
// OTA Software Update Provider Cluster server
//

/** @brief OTA Software Update Provider Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOtaSoftwareUpdateProviderClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief OTA Software Update Provider Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfOtaSoftwareUpdateProviderClusterServerAttributeChangedCallback(chip::EndpointId endpoint,
                                                                           chip::AttributeId attributeId);

/** @brief OTA Software Update Provider Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfOtaSoftwareUpdateProviderClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                               chip::AttributeId attributeId,
                                                                                               uint16_t manufacturerCode);

/** @brief OTA Software Update Provider Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfOtaSoftwareUpdateProviderClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                      EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                      EmberStatus status);

/** @brief OTA Software Update Provider Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfOtaSoftwareUpdateProviderClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                       chip::AttributeId attributeId,
                                                                                       EmberAfAttributeType attributeType,
                                                                                       uint16_t size, uint8_t * value);

/** @brief OTA Software Update Provider Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfOtaSoftwareUpdateProviderClusterServerTickCallback(chip::EndpointId endpoint);

//
// Occupancy Sensing Cluster server
//

/** @brief Occupancy Sensing Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOccupancySensingClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Occupancy Sensing Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfOccupancySensingClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Occupancy Sensing Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfOccupancySensingClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                      chip::AttributeId attributeId,
                                                                                      uint16_t manufacturerCode);

/** @brief Occupancy Sensing Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfOccupancySensingClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                             EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                             EmberStatus status);

/** @brief Occupancy Sensing Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfOccupancySensingClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                              chip::AttributeId attributeId,
                                                                              EmberAfAttributeType attributeType, uint16_t size,
                                                                              uint8_t * value);

/** @brief Occupancy Sensing Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfOccupancySensingClusterServerTickCallback(chip::EndpointId endpoint);

//
// On/off Cluster server
//

/** @brief On/off Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOnOffClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief On/off Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfOnOffClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief On/off Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                           uint16_t manufacturerCode);

/** @brief On/off Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfOnOffClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                  uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief On/off Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                   EmberAfAttributeType attributeType, uint16_t size,
                                                                   uint8_t * value);

/** @brief On/off Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfOnOffClusterServerTickCallback(chip::EndpointId endpoint);

//
// Operational Credentials Cluster server
//

/** @brief Operational Credentials Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfOperationalCredentialsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Operational Credentials Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfOperationalCredentialsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Operational Credentials Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfOperationalCredentialsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                            chip::AttributeId attributeId,
                                                                                            uint16_t manufacturerCode);

/** @brief Operational Credentials Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfOperationalCredentialsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                   EmberStatus status);

/** @brief Operational Credentials Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfOperationalCredentialsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    EmberAfAttributeType attributeType,
                                                                                    uint16_t size, uint8_t * value);

/** @brief Operational Credentials Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfOperationalCredentialsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Pressure Measurement Cluster server
//

/** @brief Pressure Measurement Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfPressureMeasurementClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Pressure Measurement Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfPressureMeasurementClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Pressure Measurement Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfPressureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                         chip::AttributeId attributeId,
                                                                                         uint16_t manufacturerCode);

/** @brief Pressure Measurement Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfPressureMeasurementClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                EmberStatus status);

/** @brief Pressure Measurement Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfPressureMeasurementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 EmberAfAttributeType attributeType, uint16_t size,
                                                                                 uint8_t * value);

/** @brief Pressure Measurement Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfPressureMeasurementClusterServerTickCallback(chip::EndpointId endpoint);

//
// Pump Configuration and Control Cluster server
//

/** @brief Pump Configuration and Control Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfPumpConfigurationAndControlClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Pump Configuration and Control Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfPumpConfigurationAndControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId);

/** @brief Pump Configuration and Control Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfPumpConfigurationAndControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                                 chip::AttributeId attributeId,
                                                                                                 uint16_t manufacturerCode);

/** @brief Pump Configuration and Control Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfPumpConfigurationAndControlClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                        EmberApsFrame * apsFrame, uint16_t msgLen,
                                                                        uint8_t * message, EmberStatus status);

/** @brief Pump Configuration and Control Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfPumpConfigurationAndControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                         chip::AttributeId attributeId,
                                                                                         EmberAfAttributeType attributeType,
                                                                                         uint16_t size, uint8_t * value);

/** @brief Pump Configuration and Control Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfPumpConfigurationAndControlClusterServerTickCallback(chip::EndpointId endpoint);

//
// Relative Humidity Measurement Cluster server
//

/** @brief Relative Humidity Measurement Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfRelativeHumidityMeasurementClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Relative Humidity Measurement Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfRelativeHumidityMeasurementClusterServerAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId);

/** @brief Relative Humidity Measurement Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfRelativeHumidityMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                                 chip::AttributeId attributeId,
                                                                                                 uint16_t manufacturerCode);

/** @brief Relative Humidity Measurement Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfRelativeHumidityMeasurementClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                        EmberApsFrame * apsFrame, uint16_t msgLen,
                                                                        uint8_t * message, EmberStatus status);

/** @brief Relative Humidity Measurement Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfRelativeHumidityMeasurementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                         chip::AttributeId attributeId,
                                                                                         EmberAfAttributeType attributeType,
                                                                                         uint16_t size, uint8_t * value);

/** @brief Relative Humidity Measurement Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfRelativeHumidityMeasurementClusterServerTickCallback(chip::EndpointId endpoint);

//
// Scenes Cluster server
//

/** @brief Scenes Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfScenesClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Scenes Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfScenesClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Scenes Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfScenesClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            uint16_t manufacturerCode);

/** @brief Scenes Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfScenesClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                   uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Scenes Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfScenesClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                    EmberAfAttributeType attributeType, uint16_t size,
                                                                    uint8_t * value);

/** @brief Scenes Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfScenesClusterServerTickCallback(chip::EndpointId endpoint);

//
// Software Diagnostics Cluster server
//

/** @brief Software Diagnostics Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfSoftwareDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Software Diagnostics Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfSoftwareDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Software Diagnostics Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfSoftwareDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                         chip::AttributeId attributeId,
                                                                                         uint16_t manufacturerCode);

/** @brief Software Diagnostics Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfSoftwareDiagnosticsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                EmberStatus status);

/** @brief Software Diagnostics Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfSoftwareDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 EmberAfAttributeType attributeType, uint16_t size,
                                                                                 uint8_t * value);

/** @brief Software Diagnostics Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfSoftwareDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Switch Cluster server
//

/** @brief Switch Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfSwitchClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Switch Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfSwitchClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Switch Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfSwitchClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            uint16_t manufacturerCode);

/** @brief Switch Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfSwitchClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                   uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Switch Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfSwitchClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                    EmberAfAttributeType attributeType, uint16_t size,
                                                                    uint8_t * value);

/** @brief Switch Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfSwitchClusterServerTickCallback(chip::EndpointId endpoint);

//
// TV Channel Cluster server
//

/** @brief TV Channel Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTvChannelClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief TV Channel Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfTvChannelClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief TV Channel Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfTvChannelClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                               chip::AttributeId attributeId,
                                                                               uint16_t manufacturerCode);

/** @brief TV Channel Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfTvChannelClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                      uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief TV Channel Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfTvChannelClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                       EmberAfAttributeType attributeType, uint16_t size,
                                                                       uint8_t * value);

/** @brief TV Channel Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfTvChannelClusterServerTickCallback(chip::EndpointId endpoint);

//
// Target Navigator Cluster server
//

/** @brief Target Navigator Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTargetNavigatorClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Target Navigator Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfTargetNavigatorClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Target Navigator Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfTargetNavigatorClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                     chip::AttributeId attributeId,
                                                                                     uint16_t manufacturerCode);

/** @brief Target Navigator Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfTargetNavigatorClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                            EmberStatus status);

/** @brief Target Navigator Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfTargetNavigatorClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                             chip::AttributeId attributeId,
                                                                             EmberAfAttributeType attributeType, uint16_t size,
                                                                             uint8_t * value);

/** @brief Target Navigator Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfTargetNavigatorClusterServerTickCallback(chip::EndpointId endpoint);

//
// Temperature Measurement Cluster server
//

/** @brief Temperature Measurement Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTemperatureMeasurementClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Temperature Measurement Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfTemperatureMeasurementClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Temperature Measurement Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfTemperatureMeasurementClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                            chip::AttributeId attributeId,
                                                                                            uint16_t manufacturerCode);

/** @brief Temperature Measurement Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfTemperatureMeasurementClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                   EmberStatus status);

/** @brief Temperature Measurement Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfTemperatureMeasurementClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    EmberAfAttributeType attributeType,
                                                                                    uint16_t size, uint8_t * value);

/** @brief Temperature Measurement Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfTemperatureMeasurementClusterServerTickCallback(chip::EndpointId endpoint);

//
// Test Cluster Cluster server
//

/** @brief Test Cluster Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfTestClusterClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Test Cluster Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfTestClusterClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Test Cluster Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfTestClusterClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 uint16_t manufacturerCode);

/** @brief Test Cluster Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfTestClusterClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                        uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Test Cluster Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfTestClusterClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                         EmberAfAttributeType attributeType, uint16_t size,
                                                                         uint8_t * value);

/** @brief Test Cluster Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfTestClusterClusterServerTickCallback(chip::EndpointId endpoint);

//
// Thermostat Cluster server
//

/** @brief Thermostat Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfThermostatClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Thermostat Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfThermostatClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Thermostat Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfThermostatClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                uint16_t manufacturerCode);

/** @brief Thermostat Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfThermostatClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                       uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Thermostat Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfThermostatClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                        EmberAfAttributeType attributeType, uint16_t size,
                                                                        uint8_t * value);

/** @brief Thermostat Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfThermostatClusterServerTickCallback(chip::EndpointId endpoint);

//
// Thread Network Diagnostics Cluster server
//

/** @brief Thread Network Diagnostics Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfThreadNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Thread Network Diagnostics Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfThreadNetworkDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Thread Network Diagnostics Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfThreadNetworkDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                              chip::AttributeId attributeId,
                                                                                              uint16_t manufacturerCode);

/** @brief Thread Network Diagnostics Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfThreadNetworkDiagnosticsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                     EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                     EmberStatus status);

/** @brief Thread Network Diagnostics Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfThreadNetworkDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                      chip::AttributeId attributeId,
                                                                                      EmberAfAttributeType attributeType,
                                                                                      uint16_t size, uint8_t * value);

/** @brief Thread Network Diagnostics Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfThreadNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Wake on LAN Cluster server
//

/** @brief Wake on LAN Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWakeOnLanClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Wake on LAN Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfWakeOnLanClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Wake on LAN Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfWakeOnLanClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                               chip::AttributeId attributeId,
                                                                               uint16_t manufacturerCode);

/** @brief Wake on LAN Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfWakeOnLanClusterServerMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame,
                                                      uint16_t msgLen, uint8_t * message, EmberStatus status);

/** @brief Wake on LAN Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfWakeOnLanClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                       EmberAfAttributeType attributeType, uint16_t size,
                                                                       uint8_t * value);

/** @brief Wake on LAN Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfWakeOnLanClusterServerTickCallback(chip::EndpointId endpoint);

//
// WiFi Network Diagnostics Cluster server
//

/** @brief WiFi Network Diagnostics Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWiFiNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief WiFi Network Diagnostics Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfWiFiNetworkDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief WiFi Network Diagnostics Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfWiFiNetworkDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                            chip::AttributeId attributeId,
                                                                                            uint16_t manufacturerCode);

/** @brief WiFi Network Diagnostics Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfWiFiNetworkDiagnosticsClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                                   EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                   EmberStatus status);

/** @brief WiFi Network Diagnostics Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfWiFiNetworkDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    EmberAfAttributeType attributeType,
                                                                                    uint16_t size, uint8_t * value);

/** @brief WiFi Network Diagnostics Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfWiFiNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);

//
// Window Covering Cluster server
//

/** @brief Window Covering Cluster Server Init
 *
 * Server Init
 *
 * @param endpoint    Endpoint that is being initialized
 */
void emberAfWindowCoveringClusterServerInitCallback(chip::EndpointId endpoint);

/** @brief Window Covering Cluster Server Attribute Changed
 *
 * Server Attribute Changed
 *
 * @param endpoint    Endpoint that is being initialized
 * @param attributeId Attribute that changed
 */
void emberAfWindowCoveringClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);

/** @brief Window Covering Cluster Server Manufacturer Specific Attribute Changed
 *
 * Server Manufacturer Specific Attribute Changed
 *
 * @param endpoint          Endpoint that is being initialized
 * @param attributeId       Attribute that changed
 * @param manufacturerCode  Manufacturer Code of the attribute that changed
 */
void emberAfWindowCoveringClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);

/** @brief Window Covering Cluster Server Message Sent
 *
 * Server Message Sent
 *
 * @param type               The type of message sent
 * @param destination        The destination to which the message was sent
 * @param apsFrame           The APS frame for the message
 * @param msgLen             The length of the message
 * @param message            The message that was sent
 * @param status             The status of the sent message
 */
void emberAfWindowCoveringClusterServerMessageSentCallback(const chip::MessageSendDestination & destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);

/** @brief Window Covering Cluster Server Pre Attribute Changed
 *
 * server Pre Attribute Changed
 *
 * @param endpoint      Endpoint that is being initialized
 * @param attributeId   Attribute to be changed
 * @param attributeType Attribute type
 * @param size          Attribute size
 * @param value         Attribute value
 */
EmberAfStatus emberAfWindowCoveringClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                            chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);

/** @brief Window Covering Cluster Server Tick
 *
 * server Tick
 *
 * @param endpoint  Endpoint that is being served
 */
void emberAfWindowCoveringClusterServerTickCallback(chip::EndpointId endpoint);

// Cluster Commands Callback

/**
 * @brief Barrier Control Cluster BarrierControlGoToPercent Command callback
 */

bool emberAfBarrierControlClusterBarrierControlGoToPercentCallback(chip::app::Command * commandObj, uint8_t percentOpen);

/**
 * @brief Barrier Control Cluster BarrierControlStop Command callback
 */

bool emberAfBarrierControlClusterBarrierControlStopCallback(chip::app::Command * commandObj);

/**
 * @brief Basic Cluster MfgSpecificPing Command callback
 */

bool emberAfBasicClusterMfgSpecificPingCallback(chip::app::Command * commandObj);

/**
 * @brief Binding Cluster Bind Command callback
 */

bool emberAfBindingClusterBindCallback(chip::app::Command * commandObj, chip::NodeId nodeId, chip::GroupId groupId,
                                       chip::EndpointId endpointId, chip::ClusterId clusterId);

/**
 * @brief Binding Cluster Unbind Command callback
 */

bool emberAfBindingClusterUnbindCallback(chip::app::Command * commandObj, chip::NodeId nodeId, chip::GroupId groupId,
                                         chip::EndpointId endpointId, chip::ClusterId clusterId);

/**
 * @brief Color Control Cluster MoveColor Command callback
 */

bool emberAfColorControlClusterMoveColorCallback(chip::app::Command * commandObj, int16_t rateX, int16_t rateY, uint8_t optionsMask,
                                                 uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveColorTemperature Command callback
 */

bool emberAfColorControlClusterMoveColorTemperatureCallback(chip::app::Command * commandObj, uint8_t moveMode, uint16_t rate,
                                                            uint16_t colorTemperatureMinimum, uint16_t colorTemperatureMaximum,
                                                            uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveHue Command callback
 */

bool emberAfColorControlClusterMoveHueCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate, uint8_t optionsMask,
                                               uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveSaturation Command callback
 */

bool emberAfColorControlClusterMoveSaturationCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate,
                                                      uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveToColor Command callback
 */

bool emberAfColorControlClusterMoveToColorCallback(chip::app::Command * commandObj, uint16_t colorX, uint16_t colorY,
                                                   uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveToColorTemperature Command callback
 */

bool emberAfColorControlClusterMoveToColorTemperatureCallback(chip::app::Command * commandObj, uint16_t colorTemperature,
                                                              uint16_t transitionTime, uint8_t optionsMask,
                                                              uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveToHue Command callback
 */

bool emberAfColorControlClusterMoveToHueCallback(chip::app::Command * commandObj, uint8_t hue, uint8_t direction,
                                                 uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveToHueAndSaturation Command callback
 */

bool emberAfColorControlClusterMoveToHueAndSaturationCallback(chip::app::Command * commandObj, uint8_t hue, uint8_t saturation,
                                                              uint16_t transitionTime, uint8_t optionsMask,
                                                              uint8_t optionsOverride);

/**
 * @brief Color Control Cluster MoveToSaturation Command callback
 */

bool emberAfColorControlClusterMoveToSaturationCallback(chip::app::Command * commandObj, uint8_t saturation,
                                                        uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster StepColor Command callback
 */

bool emberAfColorControlClusterStepColorCallback(chip::app::Command * commandObj, int16_t stepX, int16_t stepY,
                                                 uint16_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster StepColorTemperature Command callback
 */

bool emberAfColorControlClusterStepColorTemperatureCallback(chip::app::Command * commandObj, uint8_t stepMode, uint16_t stepSize,
                                                            uint16_t transitionTime, uint16_t colorTemperatureMinimum,
                                                            uint16_t colorTemperatureMaximum, uint8_t optionsMask,
                                                            uint8_t optionsOverride);

/**
 * @brief Color Control Cluster StepHue Command callback
 */

bool emberAfColorControlClusterStepHueCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                               uint8_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster StepSaturation Command callback
 */

bool emberAfColorControlClusterStepSaturationCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                                      uint8_t transitionTime, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Color Control Cluster StopMoveStep Command callback
 */

bool emberAfColorControlClusterStopMoveStepCallback(chip::app::Command * commandObj, uint8_t optionsMask, uint8_t optionsOverride);

/**
 * @brief Diagnostic Logs Cluster RetrieveLogsRequest Command callback
 */

bool emberAfDiagnosticLogsClusterRetrieveLogsRequestCallback(chip::app::Command * commandObj, uint8_t intent,
                                                             uint8_t requestedProtocol, chip::ByteSpan transferFileDesignator);

/**
 * @brief Door Lock Cluster ClearAllPins Command callback
 */

bool emberAfDoorLockClusterClearAllPinsCallback(chip::app::Command * commandObj);

/**
 * @brief Door Lock Cluster ClearAllRfids Command callback
 */

bool emberAfDoorLockClusterClearAllRfidsCallback(chip::app::Command * commandObj);

/**
 * @brief Door Lock Cluster ClearHolidaySchedule Command callback
 */

bool emberAfDoorLockClusterClearHolidayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId);

/**
 * @brief Door Lock Cluster ClearPin Command callback
 */

bool emberAfDoorLockClusterClearPinCallback(chip::app::Command * commandObj, uint16_t userId);

/**
 * @brief Door Lock Cluster ClearRfid Command callback
 */

bool emberAfDoorLockClusterClearRfidCallback(chip::app::Command * commandObj, uint16_t userId);

/**
 * @brief Door Lock Cluster ClearWeekdaySchedule Command callback
 */

bool emberAfDoorLockClusterClearWeekdayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId);

/**
 * @brief Door Lock Cluster ClearYeardaySchedule Command callback
 */

bool emberAfDoorLockClusterClearYeardayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId);

/**
 * @brief Door Lock Cluster GetHolidaySchedule Command callback
 */

bool emberAfDoorLockClusterGetHolidayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId);

/**
 * @brief Door Lock Cluster GetLogRecord Command callback
 */

bool emberAfDoorLockClusterGetLogRecordCallback(chip::app::Command * commandObj, uint16_t logIndex);

/**
 * @brief Door Lock Cluster GetPin Command callback
 */

bool emberAfDoorLockClusterGetPinCallback(chip::app::Command * commandObj, uint16_t userId);

/**
 * @brief Door Lock Cluster GetRfid Command callback
 */

bool emberAfDoorLockClusterGetRfidCallback(chip::app::Command * commandObj, uint16_t userId);

/**
 * @brief Door Lock Cluster GetUserType Command callback
 */

bool emberAfDoorLockClusterGetUserTypeCallback(chip::app::Command * commandObj, uint16_t userId);

/**
 * @brief Door Lock Cluster GetWeekdaySchedule Command callback
 */

bool emberAfDoorLockClusterGetWeekdayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId);

/**
 * @brief Door Lock Cluster GetYeardaySchedule Command callback
 */

bool emberAfDoorLockClusterGetYeardayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId);

/**
 * @brief Door Lock Cluster LockDoor Command callback
 */

bool emberAfDoorLockClusterLockDoorCallback(chip::app::Command * commandObj, uint8_t * PIN);

/**
 * @brief Door Lock Cluster SetHolidaySchedule Command callback
 */

bool emberAfDoorLockClusterSetHolidayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint32_t localStartTime,
                                                      uint32_t localEndTime, uint8_t operatingModeDuringHoliday);

/**
 * @brief Door Lock Cluster SetPin Command callback
 */

bool emberAfDoorLockClusterSetPinCallback(chip::app::Command * commandObj, uint16_t userId, uint8_t userStatus, uint8_t userType,
                                          uint8_t * pin);

/**
 * @brief Door Lock Cluster SetRfid Command callback
 */

bool emberAfDoorLockClusterSetRfidCallback(chip::app::Command * commandObj, uint16_t userId, uint8_t userStatus, uint8_t userType,
                                           uint8_t * id);

/**
 * @brief Door Lock Cluster SetUserType Command callback
 */

bool emberAfDoorLockClusterSetUserTypeCallback(chip::app::Command * commandObj, uint16_t userId, uint8_t userType);

/**
 * @brief Door Lock Cluster SetWeekdaySchedule Command callback
 */

bool emberAfDoorLockClusterSetWeekdayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId,
                                                      uint8_t daysMask, uint8_t startHour, uint8_t startMinute, uint8_t endHour,
                                                      uint8_t endMinute);

/**
 * @brief Door Lock Cluster SetYeardaySchedule Command callback
 */

bool emberAfDoorLockClusterSetYeardayScheduleCallback(chip::app::Command * commandObj, uint8_t scheduleId, uint16_t userId,
                                                      uint32_t localStartTime, uint32_t localEndTime);

/**
 * @brief Door Lock Cluster UnlockDoor Command callback
 */

bool emberAfDoorLockClusterUnlockDoorCallback(chip::app::Command * commandObj, uint8_t * PIN);

/**
 * @brief Door Lock Cluster UnlockWithTimeout Command callback
 */

bool emberAfDoorLockClusterUnlockWithTimeoutCallback(chip::app::Command * commandObj, uint16_t timeoutInSeconds, uint8_t * pin);

/**
 * @brief General Commissioning Cluster ArmFailSafe Command callback
 */

bool emberAfGeneralCommissioningClusterArmFailSafeCallback(chip::app::Command * commandObj, uint16_t expiryLengthSeconds,
                                                           uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief General Commissioning Cluster CommissioningComplete Command callback
 */

bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback(chip::app::Command * commandObj);

/**
 * @brief General Commissioning Cluster SetRegulatoryConfig Command callback
 */

bool emberAfGeneralCommissioningClusterSetRegulatoryConfigCallback(chip::app::Command * commandObj, uint8_t location,
                                                                   uint8_t * countryCode, uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Groups Cluster AddGroup Command callback
 */

bool emberAfGroupsClusterAddGroupCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t * groupName);

/**
 * @brief Groups Cluster AddGroupIfIdentifying Command callback
 */

bool emberAfGroupsClusterAddGroupIfIdentifyingCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t * groupName);

/**
 * @brief Groups Cluster GetGroupMembership Command callback
 */

bool emberAfGroupsClusterGetGroupMembershipCallback(chip::app::Command * commandObj, uint8_t groupCount,
                                                    /* TYPE WARNING: array array defaults to */ uint8_t * groupList);

/**
 * @brief Groups Cluster RemoveAllGroups Command callback
 */

bool emberAfGroupsClusterRemoveAllGroupsCallback(chip::app::Command * commandObj);

/**
 * @brief Groups Cluster RemoveGroup Command callback
 */

bool emberAfGroupsClusterRemoveGroupCallback(chip::app::Command * commandObj, uint16_t groupId);

/**
 * @brief Groups Cluster ViewGroup Command callback
 */

bool emberAfGroupsClusterViewGroupCallback(chip::app::Command * commandObj, uint16_t groupId);

/**
 * @brief IAS Zone Cluster ZoneEnrollResponse Command callback
 */

bool emberAfIasZoneClusterZoneEnrollResponseCallback(chip::app::Command * commandObj, uint8_t enrollResponseCode, uint8_t zoneId);

/**
 * @brief Identify Cluster Identify Command callback
 */

bool emberAfIdentifyClusterIdentifyCallback(chip::app::Command * commandObj, uint16_t identifyTime);

/**
 * @brief Identify Cluster IdentifyQuery Command callback
 */

bool emberAfIdentifyClusterIdentifyQueryCallback(chip::app::Command * commandObj);

/**
 * @brief Level Control Cluster Move Command callback
 */

bool emberAfLevelControlClusterMoveCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate, uint8_t optionMask,
                                            uint8_t optionOverride);

/**
 * @brief Level Control Cluster MoveToLevel Command callback
 */

bool emberAfLevelControlClusterMoveToLevelCallback(chip::app::Command * commandObj, uint8_t level, uint16_t transitionTime,
                                                   uint8_t optionMask, uint8_t optionOverride);

/**
 * @brief Level Control Cluster MoveToLevelWithOnOff Command callback
 */

bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(chip::app::Command * commandObj, uint8_t level,
                                                            uint16_t transitionTime);

/**
 * @brief Level Control Cluster MoveWithOnOff Command callback
 */

bool emberAfLevelControlClusterMoveWithOnOffCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate);

/**
 * @brief Level Control Cluster Step Command callback
 */

bool emberAfLevelControlClusterStepCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                            uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride);

/**
 * @brief Level Control Cluster StepWithOnOff Command callback
 */

bool emberAfLevelControlClusterStepWithOnOffCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                                     uint16_t transitionTime);

/**
 * @brief Level Control Cluster Stop Command callback
 */

bool emberAfLevelControlClusterStopCallback(chip::app::Command * commandObj, uint8_t optionMask, uint8_t optionOverride);

/**
 * @brief Level Control Cluster StopWithOnOff Command callback
 */

bool emberAfLevelControlClusterStopWithOnOffCallback(chip::app::Command * commandObj);

/**
 * @brief Low Power Cluster Sleep Command callback
 */

bool emberAfLowPowerClusterSleepCallback(chip::app::Command * commandObj);

/**
 * @brief Network Commissioning Cluster AddThreadNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterAddThreadNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan operationalDataset,
                                                                uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster AddWiFiNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterAddWiFiNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan ssid,
                                                              chip::ByteSpan credentials, uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster DisableNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterDisableNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan networkID,
                                                              uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster EnableNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterEnableNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan networkID,
                                                             uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster GetLastNetworkCommissioningResult Command callback
 */

bool emberAfNetworkCommissioningClusterGetLastNetworkCommissioningResultCallback(chip::app::Command * commandObj,
                                                                                 uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster RemoveNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterRemoveNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan NetworkID,
                                                             uint64_t Breadcrumb, uint32_t TimeoutMs);

/**
 * @brief Network Commissioning Cluster ScanNetworks Command callback
 */

bool emberAfNetworkCommissioningClusterScanNetworksCallback(chip::app::Command * commandObj, chip::ByteSpan ssid,
                                                            uint64_t breadcrumb, uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster UpdateThreadNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterUpdateThreadNetworkCallback(chip::app::Command * commandObj,
                                                                   chip::ByteSpan operationalDataset, uint64_t breadcrumb,
                                                                   uint32_t timeoutMs);

/**
 * @brief Network Commissioning Cluster UpdateWiFiNetwork Command callback
 */

bool emberAfNetworkCommissioningClusterUpdateWiFiNetworkCallback(chip::app::Command * commandObj, chip::ByteSpan ssid,
                                                                 chip::ByteSpan credentials, uint64_t breadcrumb,
                                                                 uint32_t timeoutMs);

/**
 * @brief OTA Software Update Provider Cluster ApplyUpdateRequest Command callback
 */

bool emberAfOtaSoftwareUpdateProviderClusterApplyUpdateRequestCallback(chip::app::Command * commandObj, chip::ByteSpan updateToken,
                                                                       uint32_t newVersion);

/**
 * @brief OTA Software Update Provider Cluster NotifyUpdateApplied Command callback
 */

bool emberAfOtaSoftwareUpdateProviderClusterNotifyUpdateAppliedCallback(chip::app::Command * commandObj, chip::ByteSpan updateToken,
                                                                        uint32_t currentVersion);

/**
 * @brief OTA Software Update Provider Cluster QueryImage Command callback
 */

bool emberAfOtaSoftwareUpdateProviderClusterQueryImageCallback(
    chip::app::Command * commandObj, uint16_t vendorId, uint16_t productId, uint16_t imageType, uint16_t hardwareVersion,
    uint32_t currentVersion, /* TYPE WARNING: array array defaults to */ uint8_t * protocolsSupported, uint8_t * location,
    uint8_t requestorCanConsent, chip::ByteSpan metadataForProvider);

/**
 * @brief On/off Cluster Off Command callback
 */

bool emberAfOnOffClusterOffCallback(chip::app::Command * commandObj);

/**
 * @brief On/off Cluster On Command callback
 */

bool emberAfOnOffClusterOnCallback(chip::app::Command * commandObj);

/**
 * @brief On/off Cluster Toggle Command callback
 */

bool emberAfOnOffClusterToggleCallback(chip::app::Command * commandObj);

/**
 * @brief Operational Credentials Cluster AddOpCert Command callback
 */

bool emberAfOperationalCredentialsClusterAddOpCertCallback(chip::app::Command * commandObj, chip::ByteSpan NOCArray,
                                                           chip::ByteSpan IPKValue, chip::NodeId CaseAdminNode,
                                                           uint16_t AdminVendorId);

/**
 * @brief Operational Credentials Cluster AddTrustedRootCertificate Command callback
 */

bool emberAfOperationalCredentialsClusterAddTrustedRootCertificateCallback(chip::app::Command * commandObj,
                                                                           chip::ByteSpan RootCertificate);

/**
 * @brief Operational Credentials Cluster OpCSRRequest Command callback
 */

bool emberAfOperationalCredentialsClusterOpCSRRequestCallback(chip::app::Command * commandObj, chip::ByteSpan CSRNonce);

/**
 * @brief Operational Credentials Cluster RemoveAllFabrics Command callback
 */

bool emberAfOperationalCredentialsClusterRemoveAllFabricsCallback(chip::app::Command * commandObj);

/**
 * @brief Operational Credentials Cluster RemoveFabric Command callback
 */

bool emberAfOperationalCredentialsClusterRemoveFabricCallback(chip::app::Command * commandObj, chip::FabricId FabricId,
                                                              chip::NodeId NodeId, uint16_t VendorId);

/**
 * @brief Operational Credentials Cluster RemoveTrustedRootCertificate Command callback
 */

bool emberAfOperationalCredentialsClusterRemoveTrustedRootCertificateCallback(chip::app::Command * commandObj,
                                                                              chip::ByteSpan TrustedRootIdentifier);

/**
 * @brief Operational Credentials Cluster SetFabric Command callback
 */

bool emberAfOperationalCredentialsClusterSetFabricCallback(chip::app::Command * commandObj, uint16_t VendorId);

/**
 * @brief Operational Credentials Cluster UpdateFabricLabel Command callback
 */

bool emberAfOperationalCredentialsClusterUpdateFabricLabelCallback(chip::app::Command * commandObj, uint8_t * Label);

/**
 * @brief Scenes Cluster AddScene Command callback
 */

bool emberAfScenesClusterAddSceneCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t sceneId,
                                          uint16_t transitionTime, uint8_t * sceneName,
                                          /* TYPE WARNING: array array defaults to */ uint8_t * extensionFieldSets);

/**
 * @brief Scenes Cluster GetSceneMembership Command callback
 */

bool emberAfScenesClusterGetSceneMembershipCallback(chip::app::Command * commandObj, uint16_t groupId);

/**
 * @brief Scenes Cluster RecallScene Command callback
 */

bool emberAfScenesClusterRecallSceneCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t sceneId,
                                             uint16_t transitionTime);

/**
 * @brief Scenes Cluster RemoveAllScenes Command callback
 */

bool emberAfScenesClusterRemoveAllScenesCallback(chip::app::Command * commandObj, uint16_t groupId);

/**
 * @brief Scenes Cluster RemoveScene Command callback
 */

bool emberAfScenesClusterRemoveSceneCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t sceneId);

/**
 * @brief Scenes Cluster StoreScene Command callback
 */

bool emberAfScenesClusterStoreSceneCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t sceneId);

/**
 * @brief Scenes Cluster ViewScene Command callback
 */

bool emberAfScenesClusterViewSceneCallback(chip::app::Command * commandObj, uint16_t groupId, uint8_t sceneId);

/**
 * @brief Test Cluster Cluster Test Command callback
 */

bool emberAfTestClusterClusterTestCallback(chip::app::Command * commandObj);

/**
 * @brief Test Cluster Cluster TestNotHandled Command callback
 */

bool emberAfTestClusterClusterTestNotHandledCallback(chip::app::Command * commandObj);

/**
 * @brief Test Cluster Cluster TestSpecific Command callback
 */

bool emberAfTestClusterClusterTestSpecificCallback(chip::app::Command * commandObj);

//
// Non-Cluster Related Callbacks
//

/** @brief Add To Current App Tasks
 *
 * This function is only useful to sleepy end devices.  This function will note
 * the passed item as part of a set of tasks the application has outstanding
 * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
 * application behaves with regard to sleeping and polling.  Until the
 * outstanding task is completed, the device may poll more frequently and sleep
 * less often.
 *
 * @param tasks   Ver.: always
 */
void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks);

/** @brief Remove From Current App Tasks
 *
 * This function is only useful to sleepy end devices.  This function will
 * remove the passed item from the set of tasks the application has outstanding
 * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
 * application behaves with regard to sleeping and polling.  Removing the item
 * from the list of outstanding tasks may allow the device to sleep longer and
 * poll less frequently.  If there are other outstanding tasks the system may
 * still have to stay away and poll more often.
 *
 * @param tasks   Ver.: always
 */
void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks);

/** @brief Allow Network Write Attribute
 *
 * This function is called by the application framework before it writes an
 * attribute in response to a write attribute request from an external device.
 * The value passed into this callback is the value to which the attribute is to
 * be set by the framework.
        Example:	In mirroring simple metering data
 * on an Energy Services Interface (ESI) (formerly called Energy Service Portal
 * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only
 * attributes on its mirror. The-meter-mirror sample application, located in
 * app/framework/sample-apps, uses this callback to allow the mirrored device to
 * write simple metering attributes on the mirror regardless of the fact that
 * most simple metering attributes are defined as read-only by the ZigBee
 * specification.
        Note:	The ZCL specification does not (as of this
 * writing) specify any permission-level security for writing writeable
 * attributes. As far as the ZCL specification is concerned, if an attribute is
 * writeable, any device that has a link key for the device should be able to
 * write that attribute. Furthermore if an attribute is read only, it should not
 * be written over the air. Thus, if you implement permissions for writing
 * attributes as a feature, you MAY be operating outside the specification. This
 * is unlikely to be a problem for writing read-only attributes, but it may be a
 * problem for attributes that are writeable according to the specification but
 * restricted by the application implementing this callback.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param attributeId   Ver.: always
 * @param mask   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param value   Ver.: always
 * @param type   Ver.: always
 */
EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                                          chip::AttributeId attributeId, uint8_t mask,
                                                                          uint16_t manufacturerCode, uint8_t * value, uint8_t type);

/** @brief Attribute Read Access
 *
 * This function is called whenever the Application Framework needs to check
 * access permission for an attribute read.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param attributeId   Ver.: always
 */
bool emberAfAttributeReadAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
                                        chip::AttributeId attributeId);

/** @brief Attribute Write Access
 *
 * This function is called whenever the Application Framework needs to check
 * access permission for an attribute write.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param attributeId   Ver.: always
 */
bool emberAfAttributeWriteAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
                                         chip::AttributeId attributeId);

/** @brief Default Response
 *
 * This function is called by the application framework when a Default Response
 * command is received from an external device.  The application should return
 * true if the message was processed or false if it was not.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param commandId The command identifier to which this is a response.  Ver.:
 * always
 * @param status Specifies either SUCCESS or the nature of the error that was
 * detected in the received command.  Ver.: always
 */
bool emberAfDefaultResponseCallback(chip::ClusterId clusterId, chip::CommandId commandId, EmberAfStatus status);

/** @brief Configure Reporting Response
 *
 * This function is called by the application framework when a Configure
 * Reporting Response command is received from an external device.  The
 * application should return true if the message was processed or false if it
 * was not.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param buffer Buffer containing the list of attribute status records.  Ver.:
 * always
 * @param bufLen The length in bytes of the list.  Ver.: always
 */
bool emberAfConfigureReportingResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);

/** @brief Read Reporting Configuration Response
 *
 * This function is called by the application framework when a Read Reporting
 * Configuration Response command is received from an external device.  The
 * application should return true if the message was processed or false if it
 * was not.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param buffer Buffer containing the list of attribute reporting configuration
 * records.  Ver.: always
 * @param bufLen The length in bytes of the list.  Ver.: always
 */
bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);

/** @brief Discover Attributes Response
 *
 * This function is called by the application framework when a Discover
 * Attributes Response or Discover Attributes Extended Response command is
 * received from an external device.  The Discover Attributes Response command
 * contains a bool indicating if discovery is complete and a list of zero or
 * more attribute identifier/type records. The final argument indicates whether
 * the response is in the extended format or not.  The application should return
 * true if the message was processed or false if it was not.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param discoveryComplete Indicates whether there are more attributes to be
 * discovered.  true if there are no more attributes to be discovered.  Ver.:
 * always
 * @param buffer Buffer containing the list of attribute identifier/type
 * records.  Ver.: always
 * @param bufLen The length in bytes of the list.  Ver.: always
 * @param extended Indicates whether the response is in the extended format or
 * not.  Ver.: always
 */
bool emberAfDiscoverAttributesResponseCallback(chip::ClusterId clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t bufLen,
                                               bool extended);

/** @brief Discover Commands Generated Response
 *
 * This function is called by the framework when Discover Commands Generated
 * Response is received.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param manufacturerCode Manufacturer code  Ver.: always
 * @param discoveryComplete Indicates whether there are more commands to be
 * discovered.  Ver.: always
 * @param commandIds Buffer containing the list of command identifiers.  Ver.:
 * always
 * @param commandIdCount The length of bytes of the list, whish is the same as
 * the number of identifiers.  Ver.: always
 */
bool emberAfDiscoverCommandsGeneratedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
                                                      chip::CommandId * commandIds, uint16_t commandIdCount);

/** @brief Discover Commands Received Response
 *
 * This function is called by the framework when Discover Commands Received
 * Response is received.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param manufacturerCode Manufacturer code  Ver.: always
 * @param discoveryComplete Indicates whether there are more commands to be
 * discovered.  Ver.: always
 * @param commandIds Buffer containing the list of command identifiers.  Ver.:
 * always
 * @param commandIdCount The length of bytes of the list, whish is the same as
 * the number of identifiers.  Ver.: always
 */
bool emberAfDiscoverCommandsReceivedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
                                                     chip::CommandId * commandIds, uint16_t commandIdCount);

/** @brief Pre Command Received
 *
 * This callback is the second in the Application Framework's message processing
 * chain. At this point in the processing of incoming over-the-air messages, the
 * application has determined that the incoming message is a ZCL command. It
 * parses enough of the message to populate an EmberAfClusterCommand struct. The
 * Application Framework defines this struct value in a local scope to the
 * command processing but also makes it available through a global pointer
 * called emberAfCurrentCommand, in app/framework/util/util.c. When command
 * processing is complete, this pointer is cleared.
 *
 * @param cmd   Ver.: always
 */
bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd);

/** @brief Pre Message Send
 *
 * This function is called by the framework when it is about to pass a message
 * to the stack primitives for sending.   This message may or may not be ZCL,
 * ZDO, or some other protocol.  This is called prior to
        any ZigBee
 * fragmentation that may be done.  If the function returns true it is assumed
 * the callback has consumed and processed the message.  The callback must also
 * set the EmberStatus status code to be passed back to the caller.  The
 * framework will do no further processing on the message.
        If the
 * function returns false then it is assumed that the callback has not processed
 * the mesasge and the framework will continue to process accordingly.
 *
 * @param messageStruct The structure containing the parameters of the APS
 * message to be sent.  Ver.: always
 * @param status A pointer to the status code value that will be returned to the
 * caller.  Ver.: always
 */
bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status);

/** @brief Message Sent
 *
 * This function is called by the application framework from the message sent
 * handler, when it is informed by the stack regarding the message sent status.
 * All of the values passed to the emberMessageSentHandler are passed on to this
 * callback. This provides an opportunity for the application to verify that its
 * message has been sent successfully and take the appropriate action. This
 * callback should return a bool value of true or false. A value of true
 * indicates that the message sent notification has been handled and should not
 * be handled by the application framework.
 *
 * @param type   Ver.: always
 * @param destination   Ver.: always
 * @param apsFrame   Ver.: always
 * @param msgLen   Ver.: always
 * @param message   Ver.: always
 * @param status   Ver.: always
 */
bool emberAfMessageSentCallback(const chip::MessageSendDestination & destination, EmberApsFrame * apsFrame, uint16_t msgLen,
                                uint8_t * message, EmberStatus status);

/** @brief Pre Attribute Change
 *
 * This function is called by the application framework before it changes an
 * attribute value.  The value passed into this callback is the value to which
 * the attribute is to be set by the framework.  The application should return
 * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus
 * to reject it.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param attributeId   Ver.: always
 * @param mask   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param type   Ver.: always
 * @param size   Ver.: always
 * @param value   Ver.: always
 */
EmberAfStatus emberAfPreAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
                                                uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint16_t size,
                                                uint8_t * value);

/** @brief Post Attribute Change
 *
 * This function is called by the application framework after it changes an
 * attribute value. The value passed into this callback is the value to which
 * the attribute was set by the framework.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param attributeId   Ver.: always
 * @param mask   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param type   Ver.: always
 * @param size   Ver.: always
 * @param value   Ver.: always
 */
void emberAfPostAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
                                        uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint16_t size, uint8_t * value);

/** @brief External Attribute Read
 *
 * Like emberAfExternalAttributeWriteCallback above, this function is called
 * when the framework needs to read an attribute that is not stored within the
 * Application Framework's data structures.
        All of the important
 * information about the attribute itself is passed as a pointer to an
 * EmberAfAttributeMetadata struct, which is stored within the application and
 * used to manage the attribute. A complete description of the
 * EmberAfAttributeMetadata struct is provided in
 * app/framework/include/af-types.h
        This function assumes that the
 * application is able to read the attribute, write it into the passed buffer,
 * and return immediately. Any attributes that require a state machine for
 * reading and writing are not really candidates for externalization at the
 * present time. The Application Framework does not currently include a state
 * machine for reading or writing attributes that must take place across a
 * series of application ticks. Attributes that cannot be read in a timely
 * manner should be stored within the Application Framework and updated
 * occasionally by the application code from within the
 * emberAfMainTickCallback.
        If the application was successfully able to
 * read the attribute and write it into the passed buffer, it should return a
 * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally
 * managed attribute value is smaller than what the buffer can hold. In the case
 * of a buffer overflow throw an appropriate error such as
 * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the
 * application was not able to read the attribute.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param attributeMetadata   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param buffer   Ver.: always
 * @param maxReadLength   Ver.: always
 * @param index   Ver.: always
 */
EmberAfStatus emberAfExternalAttributeReadCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                   EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
                                                   uint8_t * buffer, uint16_t maxReadLength, int32_t index = -1);

/** @brief Write Attributes Response
 *
 * This function is called by the application framework when a Write Attributes
 * Response command is received from an external device.  The application should
 * return true if the message was processed or false if it was not.
 *
 * @param clusterId The cluster identifier of this response.  Ver.: always
 * @param buffer Buffer containing the list of write attribute status records.
 * Ver.: always
 * @param bufLen The length in bytes of the list.  Ver.: always
 */
bool emberAfWriteAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);

/** @brief External Attribute Write
 *
 * This function is called whenever the Application Framework needs to write an
 * attribute which is not stored within the data structures of the Application
 * Framework itself. One of the new features in Version 2 is the ability to
 * store attributes outside the Framework. This is particularly useful for
 * attributes that do not need to be stored because they can be read off the
 * hardware when they are needed, or are stored in some central location used by
 * many modules within the system. In this case, you can indicate that the
 * attribute is stored externally. When the framework needs to write an external
 * attribute, it makes a call to this callback.
        This callback is very
 * useful for host micros which need to store attributes in persistent memory.
 * Because each host micro (used with an Ember NCP) has its own type of
 * persistent memory storage, the Application Framework does not include the
 * ability to mark attributes as stored in flash the way that it does for Ember
 * SoCs like the EM35x. On a host micro, any attributes that need to be stored
 * in persistent memory should be marked as external and accessed through the
 * external read and write callbacks. Any host code associated with the
 * persistent storage should be implemented within this callback.
        All of
 * the important information about the attribute itself is passed as a pointer
 * to an EmberAfAttributeMetadata struct, which is stored within the application
 * and used to manage the attribute. A complete description of the
 * EmberAfAttributeMetadata struct is provided in
 * app/framework/include/af-types.h.
        This function assumes that the
 * application is able to write the attribute and return immediately. Any
 * attributes that require a state machine for reading and writing are not
 * candidates for externalization at the present time. The Application Framework
 * does not currently include a state machine for reading or writing attributes
 * that must take place across a series of application ticks. Attributes that
 * cannot be written immediately should be stored within the Application
 * Framework and updated occasionally by the application code from within the
 * emberAfMainTickCallback.
        If the application was successfully able to
 * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any
 * other return value indicates the application was not able to write the
 * attribute.
 *
 * @param endpoint   Ver.: always
 * @param clusterId   Ver.: always
 * @param attributeMetadata   Ver.: always
 * @param manufacturerCode   Ver.: always
 * @param buffer   Ver.: always
 * @param index   Ver.: always
 */
EmberAfStatus emberAfExternalAttributeWriteCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                    EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
                                                    uint8_t * buffer, int32_t index = -1);

/** @brief Report Attributes
 *
 * This function is called by the application framework when a Report Attributes
 * command is received from an external device.  The application should return
 * true if the message was processed or false if it was not.
 *
 * @param clusterId The cluster identifier of this command.  Ver.: always
 * @param buffer Buffer containing the list of attribute report records.  Ver.:
 * always
 * @param bufLen The length in bytes of the list.  Ver.: always
 */
bool emberAfReportAttributesCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);

/** @brief Get Current Time
 *
 * This callback is called when device attempts to get current time from the
 * hardware. If this device has means to retrieve exact time, then this method
 * should implement it. If the callback can't provide the exact time it should
 * return 0 to indicate failure. Default action is to return 0, which indicates
 * that device does not have access to real time.
 *
 */
uint32_t emberAfGetCurrentTimeCallback();

/** @brief Get Endpoint Info
 *
 * This function is a callback to an application implemented endpoint that
 * operates outside the normal application framework.  When the framework wishes
 * to perform operations with that endpoint it uses this callback to retrieve
 * the endpoint's information.  If the endpoint exists and the application can
 * provide data then true shall be returned.  Otherwise the callback must return
 * false.
 *
 * @param endpoint The endpoint to retrieve data for.  Ver.: always
 * @param returnNetworkIndex The index corresponding to the ZigBee network the
 * endpoint belongs to.  If not using a multi-network device, 0 must be
 * returned.  Otherwise on a multi-network device the stack will switch to this
 * network before sending the message.  Ver.: always
 * @param returnEndpointInfo A pointer to a data struct that will be written
 * with information about the endpoint.  Ver.: always
 */
bool emberAfGetEndpointInfoCallback(chip::EndpointId endpoint, uint8_t * returnNetworkIndex,
                                    EmberAfEndpointInfoStruct * returnEndpointInfo);

/** @brief Registration Abort
 *
 * This callback is called when the device should abort the registration
 * process.
 *
 */
void emberAfRegistrationAbortCallback();

/** @brief Interpan Send Message
 *
 * This function will send a raw MAC message with interpan frame format using
 * the passed parameters.
 *
 * @param header Interpan header info  Ver.: always
 * @param messageLength The length of the message received or to send  Ver.:
 * always
 * @param message The message data received or to send.  Ver.: always
 */
EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message);

/** @brief Start Move
 *
 * This function is called to initiate the process for a device to move (rejoin)
 * to a new parent.
 *
 */
bool emberAfStartMoveCallback();
